पायथन FastAPI मिडलवेयर: अनुरोध और प्रतिक्रिया प्रसंस्करण के लिए एक व्यापक गाइड

आधुनिक वेब डेवलपमेंट की दुनिया में, प्रदर्शन, सुरक्षा और रखरखाव सर्वोपरि हैं। पायथन के FastAPI फ्रेमवर्क ने अपनी अविश्वसनीय गति और डेवलपर-अनुकूल सुविधाओं के लिए तेजी से लोकप्रियता हासिल की है। इसकी सबसे शक्तिशाली लेकिन कभी-कभी गलत समझी जाने वाली विशेषताओं में से एक मिडलवेयर है। मिडलवेयर अनुरोध और प्रतिक्रिया प्रसंस्करण की श्रृंखला में एक महत्वपूर्ण कड़ी के रूप में कार्य करता है, जिससे डेवलपर्स को अनुरोध के गंतव्य तक पहुंचने से पहले या क्लाइंट को प्रतिक्रिया वापस भेजने से पहले कोड निष्पादित करने, डेटा को संशोधित करने और नियमों को लागू करने की अनुमति मिलती है।

यह व्यापक गाइड डेवलपर्स के वैश्विक दर्शकों के लिए डिज़ाइन किया गया है, जो FastAPI के साथ शुरुआत कर रहे हैं, उन अनुभवी पेशेवरों के लिए जो अपनी समझ को गहरा करना चाहते हैं। हम मिडलवेयर की मुख्य अवधारणाओं का पता लगाएंगे, कस्टम समाधान बनाने का तरीका प्रदर्शित करेंगे, और व्यावहारिक, वास्तविक दुनिया के उपयोग के मामलों के माध्यम से चलेंगे। अंत तक, आप अधिक मजबूत, सुरक्षित और कुशल API बनाने के लिए मिडलवेयर का लाभ उठाने के लिए तैयार रहेंगे।

वेब फ्रेमवर्क के संदर्भ में मिडलवेयर क्या है?

कोड में गोता लगाने से पहले, अवधारणा को समझना आवश्यक है। अपने एप्लिकेशन के अनुरोध-प्रतिक्रिया चक्र को एक पाइपलाइन या एक असेंबली लाइन के रूप में कल्पना करें। जब कोई क्लाइंट आपके API को अनुरोध भेजता है, तो यह तुरंत आपके एंडपॉइंट लॉजिक को हिट नहीं करता है। इसके बजाय, यह प्रसंस्करण चरणों की एक श्रृंखला के माध्यम से यात्रा करता है। इसी तरह, जब आपका एंडपॉइंट एक प्रतिक्रिया उत्पन्न करता है, तो यह क्लाइंट तक पहुंचने से पहले इन चरणों के माध्यम से वापस यात्रा करता है। मिडलवेयर घटक पाइपलाइन में ये बहुत ही चरण हैं।

एक लोकप्रिय सादृश्य प्याज मॉडल है। प्याज का मूल आपके एप्लिकेशन का व्यवसाय तर्क (एंडपॉइंट) है। कोर को घेरने वाली प्याज की प्रत्येक परत मिडलवेयर का एक टुकड़ा है। अनुरोध को कोर तक पहुंचने के लिए प्रत्येक बाहरी परत के माध्यम से छीलना होगा, और प्रतिक्रिया समान परतों के माध्यम से वापस बाहर की ओर यात्रा करती है। प्रत्येक परत अंदर की ओर अपने रास्ते पर अनुरोध और बाहर की ओर अपने रास्ते पर प्रतिक्रिया का निरीक्षण और संशोधित कर सकती है।

संक्षेप में, मिडलवेयर एक फ़ंक्शन या क्लास है जिसकी अनुरोध ऑब्जेक्ट, प्रतिक्रिया ऑब्जेक्ट और एप्लिकेशन के अनुरोध-प्रतिक्रिया चक्र में अगले मिडलवेयर तक पहुंच है। इसके प्राथमिक उद्देश्यों में शामिल हैं:

• कोड निष्पादित करना: प्रत्येक आने वाले अनुरोध के लिए क्रियाएं करें, जैसे लॉगिंग या प्रदर्शन निगरानी।
• अनुरोध और प्रतिक्रिया को संशोधित करना: हेडर जोड़ें, प्रतिक्रिया निकायों को संपीड़ित करें, या डेटा प्रारूपों को बदलें।
• चक्र को शॉर्ट-सर्किट करना: अनुरोध-प्रतिक्रिया चक्र को जल्दी समाप्त करें। उदाहरण के लिए, एक प्रमाणीकरण मिडलवेयर एक अनधिकृत अनुरोध को इच्छित एंडपॉइंट तक पहुंचने से पहले ही ब्लॉक कर सकता है।
• वैश्विक चिंताओं का प्रबंधन: केंद्रीकृत स्थान पर त्रुटि प्रबंधन, CORS (क्रॉस-ओरिजिन रिसोर्स शेयरिंग) और सत्र प्रबंधन जैसी क्रॉस-कटिंग चिंताओं को संभालें।

FastAPI स्टारलेट टूलकिट के शीर्ष पर बनाया गया है, जो ASGI (एसिंक्रोनस सर्वर गेटवे इंटरफ़ेस) मानक का एक मजबूत कार्यान्वयन प्रदान करता है। मिडलवेयर ASGI में एक मौलिक अवधारणा है, जो इसे FastAPI पारिस्थितिकी तंत्र में प्रथम श्रेणी का नागरिक बनाती है।

सबसे सरल रूप: एक डेकोरेटर के साथ FastAPI मिडलवेयर

FastAPI @app.middleware("http") डेकोरेटर का उपयोग करके मिडलवेयर जोड़ने का एक सीधा तरीका प्रदान करता है। यह सरल, स्व-निहित तर्क के लिए एकदम सही है जिसे प्रत्येक HTTP अनुरोध के लिए चलाने की आवश्यकता है।

आइए एक क्लासिक उदाहरण बनाएं: प्रत्येक अनुरोध के लिए प्रसंस्करण समय की गणना करने और इसे प्रतिक्रिया हेडर में जोड़ने के लिए एक मिडलवेयर। यह प्रदर्शन निगरानी के लिए अविश्वसनीय रूप से उपयोगी है।

उदाहरण: एक प्रक्रिया-समय मिडलवेयर

सबसे पहले, सुनिश्चित करें कि आपके पास FastAPI और Uvicorn जैसा ASGI सर्वर स्थापित है:

pip install fastapi uvicorn

अब, main.py नामक फ़ाइल में कोड लिखें:

import time

from fastapi import FastAPI, Request

app = FastAPI()

# मिडलवेयर फ़ंक्शन को परिभाषित करें

@app.middleware("http")

async def add_process_time_header(request: Request, call_next):

# अनुरोध आने पर प्रारंभ समय रिकॉर्ड करें

start_time = time.time()

# अगले मिडलवेयर या एंडपॉइंट पर आगे बढ़ें

response = await call_next(request)

# प्रसंस्करण समय की गणना करें

process_time = time.time() - start_time

# प्रतिक्रिया में कस्टम हेडर जोड़ें

response.headers["X-Process-Time"] = str(process_time)

return response

@app.get("/")

async def root():

# कुछ काम का अनुकरण करें

time.sleep(0.5)

return {"message": "नमस्ते दुनिया!"}

इस एप्लिकेशन को चलाने के लिए, कमांड का उपयोग करें:

uvicorn main:app --reload

अब, यदि आप cURL जैसे टूल या पोस्टमैन जैसे API क्लाइंट का उपयोग करके http://127.0.0.1:8000 पर एक अनुरोध भेजते हैं, तो आपको प्रतिक्रिया में एक नया हेडर दिखाई देगा, X-Process-Time, जिसका मान लगभग 0.5 सेकंड है।

कोड का विघटन:

• @app.middleware("http"): यह डेकोरेटर हमारे फ़ंक्शन को HTTP मिडलवेयर के एक टुकड़े के रूप में पंजीकृत करता है।
• async def add_process_time_header(request: Request, call_next):: मिडलवेयर फ़ंक्शन अतुल्यकालिक होना चाहिए। यह आने वाले Request ऑब्जेक्ट और एक विशेष फ़ंक्शन, call_next को प्राप्त करता है।
• response = await call_next(request): यह सबसे महत्वपूर्ण पंक्ति है। call_next अनुरोध को पाइपलाइन में अगले चरण (या तो एक और मिडलवेयर या वास्तविक पथ संचालन) को पास करता है। आपको इस कॉल को आवश्यक `प्रतीक्षा` करनी होगी। परिणाम एंडपॉइंट द्वारा उत्पन्न Response ऑब्जेक्ट है।
• response.headers[...] = ...: एंडपॉइंट से प्रतिक्रिया प्राप्त होने के बाद, हम इसे संशोधित कर सकते हैं, इस मामले में, एक कस्टम हेडर जोड़कर।
• return response: अंत में, संशोधित प्रतिक्रिया को क्लाइंट को भेजे जाने के लिए वापस कर दिया जाता है।

कक्षाओं के साथ अपना खुद का कस्टम मिडलवेयर बनाना

जबकि डेकोरेटर दृष्टिकोण सरल है, यह अधिक जटिल परिदृश्यों के लिए सीमित हो सकता है, खासकर जब आपके मिडलवेयर को कॉन्फ़िगरेशन की आवश्यकता होती है या कुछ आंतरिक स्थिति का प्रबंधन करने की आवश्यकता होती है। इन मामलों के लिए, FastAPI (स्टारलेट के माध्यम से) BaseHTTPMiddleware का उपयोग करके क्लास-आधारित मिडलवेयर का समर्थन करता है।

एक क्लास-आधारित दृष्टिकोण बेहतर संरचना प्रदान करता है, इसके कंस्ट्रक्टर में निर्भरता इंजेक्शन की अनुमति देता है, और आम तौर पर जटिल तर्क के लिए अधिक रखरखाव योग्य होता है। मूल तर्क एक अतुल्यकालिक dispatch विधि में रहता है।

उदाहरण: एक क्लास-आधारित API कुंजी प्रमाणीकरण मिडलवेयर

आइए एक अधिक व्यावहारिक मिडलवेयर बनाएं जो हमारे API को सुरक्षित करता है। यह एक विशिष्ट हेडर, X-API-Key की जांच करेगा, और यदि कुंजी मौजूद नहीं है या अमान्य है, तो यह तुरंत 403 निषिद्ध त्रुटि प्रतिक्रिया वापस कर देगा। यह अनुरोध को "शॉर्ट-सर्किट" करने का एक उदाहरण है।

main.py में:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint

from starlette.responses import Response

# वैध API कुंजियों की एक सूची। एक वास्तविक एप्लिकेशन में, यह एक डेटाबेस या एक सुरक्षित वॉल्ट से आएगा।

VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]

class APIKeyMiddleware(BaseHTTPMiddleware):

async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

api_key = request.headers.get("X-API-Key")

if api_key not in VALID_API_KEYS:

# अनुरोध को शॉर्ट-सर्किट करें और एक त्रुटि प्रतिक्रिया वापस करें

return JSONResponse(

status_code=403,

content={"detail": "निषिद्ध: अमान्य या गुम API कुंजी"}

)

# यदि कुंजी मान्य है, तो अनुरोध के साथ आगे बढ़ें

response = await call_next(request)

return response

app = FastAPI()

# एप्लिकेशन में मिडलवेयर जोड़ें

app.add_middleware(APIKeyMiddleware)

@app.get("/")

async def root():

return {"message": "सुरक्षित क्षेत्र में आपका स्वागत है!"}

अब, जब आप इस एप्लिकेशन को चलाते हैं:

• X-API-Key हेडर के बिना (या गलत मान के साथ) एक अनुरोध को 403 स्थिति कोड और JSON त्रुटि संदेश प्राप्त होगा।
• हेडर X-API-Key: my-super-secret-key के साथ एक अनुरोध सफल होगा और 200 OK प्रतिक्रिया प्राप्त होगी।

यह पैटर्न बेहद शक्तिशाली है। / पर एंडपॉइंट कोड को API कुंजी सत्यापन के बारे में कुछ भी जानने की आवश्यकता नहीं है; वह चिंता पूरी तरह से मिडलवेयर परत में अलग हो गई है।

मिडलवेयर के लिए सामान्य और शक्तिशाली उपयोग के मामले

मिडलवेयर क्रॉस-कटिंग चिंताओं को संभालने के लिए एकदम सही उपकरण है। आइए कुछ सबसे सामान्य और प्रभावशाली उपयोग के मामलों का पता लगाएं।

1. केंद्रीकृत लॉगिंग

व्यापक लॉगिंग उत्पादन अनुप्रयोगों के लिए गैर-परक्राम्य है। मिडलवेयर आपको एक एकल बिंदु बनाने की अनुमति देता है जहां आप प्रत्येक अनुरोध और उसकी संबंधित प्रतिक्रिया के बारे में महत्वपूर्ण जानकारी लॉग करते हैं।

उदाहरण लॉगिंग मिडलवेयर:

import logging

from fastapi import FastAPI, Request

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def logging_middleware(request: Request, call_next):

start_time = time.time()

# अनुरोध विवरण लॉग करें

logger.info(f"आने वाला अनुरोध: {request.method} {request.url.path}")

response = await call_next(request)

process_time = time.time() - start_time

# प्रतिक्रिया विवरण लॉग करें

logger.info(f"प्रतिक्रिया स्थिति: {response.status_code} | प्रक्रिया का समय: {process_time:.4f}s")

return response

यह मिडलवेयर अंदर की ओर अनुरोध विधि और पथ को लॉग करता है, और बाहर की ओर प्रतिक्रिया स्थिति कोड और कुल प्रसंस्करण समय को लॉग करता है। यह आपके एप्लिकेशन के ट्रैफ़िक में अमूल्य दृश्यता प्रदान करता है।

2. वैश्विक त्रुटि प्रबंधन

डिफ़ॉल्ट रूप से, आपके कोड में एक अनियंत्रित अपवाद के परिणामस्वरूप 500 आंतरिक सर्वर त्रुटि होगी, संभावित रूप से क्लाइंट को स्टैक ट्रेस और कार्यान्वयन विवरण उजागर होंगे। एक वैश्विक त्रुटि प्रबंधन मिडलवेयर सभी अपवादों को पकड़ सकता है, उन्हें आंतरिक समीक्षा के लिए लॉग कर सकता है, और एक मानकीकृत, उपयोगकर्ता के अनुकूल त्रुटि प्रतिक्रिया वापस कर सकता है।

उदाहरण त्रुटि प्रबंधन मिडलवेयर:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

import logging

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def error_handling_middleware(request: Request, call_next):

try:

return await call_next(request)

except Exception as e:

logger.error(f"एक अनियंत्रित त्रुटि हुई: {e}", exc_info=True)

return JSONResponse(

status_code=500,

content={"detail": "एक आंतरिक सर्वर त्रुटि हुई। कृपया बाद में पुनः प्रयास करें।"}

)

@app.get("/error")

async def cause_error():

return 1 / 0 # यह एक ZeroDivisionError बढ़ाएगा

इस मिडलवेयर के साथ, /error पर एक अनुरोध अब सर्वर को क्रैश नहीं करेगा या स्टैक ट्रेस को उजागर नहीं करेगा। इसके बजाय, यह खूबसूरती से एक स्वच्छ JSON बॉडी के साथ 500 स्थिति कोड वापस कर देगा, जबकि डेवलपर्स की जांच के लिए पूर्ण त्रुटि सर्वर-साइड पर लॉग की जाती है।

3. CORS (क्रॉस-ओरिजिन रिसोर्स शेयरिंग)

यदि आपका फ्रंटएंड एप्लिकेशन आपके FastAPI बैकएंड की तुलना में एक अलग डोमेन, प्रोटोकॉल या पोर्ट से परोसा जाता है, तो ब्राउज़र समान-ओरिजिन नीति के कारण अनुरोधों को ब्लॉक कर देंगे। CORS इस नीति को शिथिल करने का तंत्र है। FastAPI इस सटीक उद्देश्य के लिए एक समर्पित, अत्यधिक कॉन्फ़िगर करने योग्य `CORSMiddleware` प्रदान करता है।

उदाहरण CORS कॉन्फ़िगरेशन:

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# अनुमत मूल की सूची को परिभाषित करें। सार्वजनिक API के लिए "*" का उपयोग करें, लेकिन बेहतर सुरक्षा के लिए विशिष्ट रहें।

origins = [

"http://localhost:3000",

"https://my-production-frontend.com",

]

app.add_middleware(

CORSMiddleware,

allow_origins=origins,

allow_credentials=True, # क्रॉस-ओरिजिन अनुरोधों में कुकीज़ को शामिल करने की अनुमति दें

allow_methods=["*"], # सभी मानक HTTP विधियों की अनुमति दें

allow_headers=["*"], # सभी हेडर की अनुमति दें

)

यह मिडलवेयर का पहला टुकड़ा है जिसे आप संभवतः एक डीकपल किए गए फ्रंटएंड के साथ किसी भी प्रोजेक्ट में जोड़ेंगे, जिससे एक ही, केंद्रीय स्थान से क्रॉस-ओरिजिन नीतियों का प्रबंधन करना सरल हो जाएगा।

4. GZip संपीड़न

HTTP प्रतिक्रियाओं को संपीड़ित करने से उनका आकार काफी कम हो सकता है, जिससे क्लाइंट के लिए लोड समय तेज हो सकता है और बैंडविड्थ लागत कम हो सकती है। FastAPI इसे स्वचालित रूप से संभालने के लिए एक `GZipMiddleware` शामिल करता है।

उदाहरण GZip मिडलवेयर:

from fastapi import FastAPI

from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# GZip मिडलवेयर जोड़ें। आप संपीड़न के लिए न्यूनतम आकार सेट कर सकते हैं।

app.add_middleware(GZipMiddleware, minimum_size=1000)

@app.get("/")

async def root():

# यह प्रतिक्रिया छोटी है और gzipped नहीं की जाएगी।

return {"message": "नमस्ते दुनिया"}

@app.get("/large-data")

async def large_data():

# इस बड़ी प्रतिक्रिया को मिडलवेयर द्वारा स्वचालित रूप से gzipped किया जाएगा।

return {"data": "a_very_long_string..." * 1000}

इस मिडलवेयर के साथ, 1000 बाइट्स से बड़ी कोई भी प्रतिक्रिया संपीड़ित की जाएगी यदि क्लाइंट इंगित करता है कि यह GZip एन्कोडिंग स्वीकार करता है (जो लगभग सभी आधुनिक ब्राउज़र और क्लाइंट करते हैं)।

उन्नत अवधारणाएँ और सर्वोत्तम प्रथाएँ

जैसे ही आप मिडलवेयर के साथ अधिक कुशल हो जाते हैं, साफ, कुशल और अनुमानित कोड लिखने के लिए कुछ बारीकियों और सर्वोत्तम प्रथाओं को समझना महत्वपूर्ण है।

1. मिडलवेयर ऑर्डर मायने रखता है!

यह याद रखने का सबसे महत्वपूर्ण नियम है। मिडलवेयर को एप्लिकेशन में जोड़े जाने के क्रम में संसाधित किया जाता है। जोड़ा गया पहला मिडलवेयर "प्याज" की सबसे बाहरी परत है।

इस सेटअप पर विचार करें:

app.add_middleware(ErrorHandlingMiddleware) # सबसे बाहरी

app.add_middleware(LoggingMiddleware)

app.add_middleware(AuthenticationMiddleware) # सबसे भीतरी

एक अनुरोध का प्रवाह होगा:

1. ErrorHandlingMiddleware अनुरोध प्राप्त करता है। यह अपने `call_next` को `try...except` ब्लॉक में लपेटता है।
2. यह `next` को कॉल करता है, अनुरोध को `LoggingMiddleware` को पास करता है।
3. LoggingMiddleware अनुरोध प्राप्त करता है, इसे लॉग करता है, और `next` को कॉल करता है।
4. AuthenticationMiddleware अनुरोध प्राप्त करता है, क्रेडेंशियल्स को मान्य करता है, और `next` को कॉल करता है।
5. अनुरोध अंत में एंडपॉइंट तक पहुंचता है।
6. एंडपॉइंट एक प्रतिक्रिया वापस करता है।
7. AuthenticationMiddleware प्रतिक्रिया प्राप्त करता है और इसे ऊपर पास करता है।
8. LoggingMiddleware प्रतिक्रिया प्राप्त करता है, इसे लॉग करता है, और इसे ऊपर पास करता है।
9. ErrorHandlingMiddleware अंतिम प्रतिक्रिया प्राप्त करता है और इसे क्लाइंट को वापस कर देता है।

यह क्रम तार्किक है: त्रुटि हैंडलर बाहर की तरफ है ताकि वह अन्य मिडलवेयर सहित किसी भी बाद की परत से त्रुटियों को पकड़ सके। प्रमाणीकरण परत अंदर की तरफ गहरी है, इसलिए हम उन अनुरोधों को लॉग या संसाधित करने की जहमत नहीं उठाते हैं जिन्हें वैसे भी अस्वीकार कर दिया जाएगा।

2. `request.state` के साथ डेटा पास करना

कभी-कभी, एक मिडलवेयर को एंडपॉइंट को जानकारी पास करने की आवश्यकता होती है। उदाहरण के लिए, एक प्रमाणीकरण मिडलवेयर एक JWT को डीकोड कर सकता है और उपयोगकर्ता की ID निकाल सकता है। यह पथ संचालन फ़ंक्शन के लिए इस उपयोगकर्ता ID को कैसे उपलब्ध करा सकता है?

गलत तरीका है अनुरोध ऑब्जेक्ट को सीधे संशोधित करना। सही तरीका है request.state ऑब्जेक्ट का उपयोग करना। यह इस सटीक उद्देश्य के लिए प्रदान किया गया एक सरल, खाली ऑब्जेक्ट है।

उदाहरण: मिडलवेयर से उपयोगकर्ता डेटा पास करना

# आपके प्रमाणीकरण मिडलवेयर की डिस्पैच विधि में:

# ... टोकन को मान्य करने और उपयोगकर्ता को डीकोड करने के बाद ...

user_data = {"id": 123, "username": "global_dev"}

request.state.user = user_data

response = await call_next(request)

# आपके एंडपॉइंट में:

@app.get("/profile")

async def get_user_profile(request: Request):

current_user = request.state.user

return {"profile_for": current_user}

यह तर्क को साफ रखता है और `Request` ऑब्जेक्ट के नामस्थान को दूषित करने से बचाता है।

3. प्रदर्शन संबंधी विचार

जबकि मिडलवेयर शक्तिशाली है, प्रत्येक परत ओवरहेड की थोड़ी मात्रा जोड़ती है। उच्च-प्रदर्शन अनुप्रयोगों के लिए, इन बिंदुओं को ध्यान में रखें:

• इसे दुबला रखें: मिडलवेयर लॉजिक जितना संभव हो उतना तेज और कुशल होना चाहिए।
• अतुल्यकालिक बनें: यदि आपके मिडलवेयर को I/O संचालन (जैसे डेटाबेस चेक) करने की आवश्यकता है, तो सुनिश्चित करें कि यह सर्वर के ईवेंट लूप को अवरुद्ध करने से बचने के लिए पूरी तरह से `async` है।
• उद्देश्य के साथ उपयोग करें: उन मिडलवेयर को न जोड़ें जिनकी आपको आवश्यकता नहीं है। प्रत्येक कॉल स्टैक की गहराई और प्रसंस्करण समय में जुड़ जाता है।

4. अपने मिडलवेयर का परीक्षण करना

मिडलवेयर आपके एप्लिकेशन के तर्क का एक महत्वपूर्ण हिस्सा है और इसका अच्छी तरह से परीक्षण किया जाना चाहिए। FastAPI का `TestClient` इसे सीधा बनाता है। आप ऐसे परीक्षण लिख सकते हैं जो आवश्यक शर्तों के साथ और बिना अनुरोध भेजते हैं (उदाहरण के लिए, एक वैध API कुंजी के साथ और बिना) और दावा करते हैं कि मिडलवेयर अपेक्षित रूप से व्यवहार करता है।

APIKeyMiddleware के लिए उदाहरण परीक्षण:

from fastapi.testclient import TestClient

from .main import app # अपना FastAPI ऐप आयात करें

client = TestClient(app)

def test_request_without_api_key_is_forbidden():

response = client.get("/")

assert response.status_code == 403

assert response.json() == {"detail": "निषिद्ध: अमान्य या गुम API कुंजी"}

def test_request_with_valid_api_key_is_successful():

headers = {"X-API-Key": "my-super-secret-key"}

response = client.get("/", headers=headers)

assert response.status_code == 200

assert response.json() == {"message": "सुरक्षित क्षेत्र में आपका स्वागत है!"}

निष्कर्ष

FastAPI मिडलवेयर किसी भी डेवलपर के लिए एक मौलिक और शक्तिशाली उपकरण है जो आधुनिक वेब API बना रहा है। यह क्रॉस-कटिंग चिंताओं को संभालने का एक सुरुचिपूर्ण और पुन: प्रयोज्य तरीका प्रदान करता है, उन्हें आपके मूल व्यवसाय तर्क से अलग करता है। प्रत्येक अनुरोध और प्रतिक्रिया को रोककर और संसाधित करके, मिडलवेयर आपको मजबूत लॉगिंग, केंद्रीकृत त्रुटि प्रबंधन, सख्त सुरक्षा नीतियों और संपीड़न जैसे प्रदर्शन संवर्द्धन को लागू करने की अनुमति देता है।

सरल @app.middleware("http") डेकोरेटर से लेकर परिष्कृत, क्लास-आधारित समाधानों तक, आपके पास अपनी आवश्यकताओं के लिए सही दृष्टिकोण चुनने की लचीलाता है। मुख्य अवधारणाओं, सामान्य उपयोग के मामलों और मिडलवेयर ऑर्डरिंग और राज्य प्रबंधन जैसी सर्वोत्तम प्रथाओं को समझकर, आप क्लीनर, अधिक सुरक्षित और अत्यधिक रखरखाव योग्य FastAPI एप्लिकेशन बना सकते हैं।

अब आपकी बारी है। अपने अगले FastAPI प्रोजेक्ट में कस्टम मिडलवेयर को एकीकृत करना शुरू करें और अपने API डिज़ाइन में नियंत्रण और लालित्य का एक नया स्तर अनलॉक करें। संभावनाएं विशाल हैं, और इस सुविधा में महारत हासिल करने से निस्संदेह आप एक अधिक प्रभावी और कुशल डेवलपर बनेंगे।